Phase B of solver refactor (issue #628). Makes the Solver instance the
canonical owner of solver-side state.

- Base Solver.__init__ now initializes options, status, solution, report,
  solver_model, io_api, env, capability, _env_stack.
- Adds to_solver_model / update_solver_model / resolve / close / __del__
  on the base class; resolve dispatches to per-subclass _resolve.
- Adds _make_result helper that populates instance state and stamps
  solver_name and report onto Result.
- Gurobi: env creation moved off per-call ExitStack onto self._env_stack
  so the env remains valid after solve returns; to_solver_model and
  _resolve overrides wired.
- Highs / Mosek / cuPDLPx: to_solver_model + _resolve overrides; Mosek
  task is now kept alive via self._env_stack instead of being closed at
  function exit.
- CBC / GLPK / Cplex / SCIP / Xpress / Knitro / COPT / MindOpt: minimal
  wiring — populate self.status/self.solution/self.solver_model/self.io_api
  via _make_result and pass solver_name + report (where readily
  available) into the returned Result.

solve_problem dispatcher and the public solve_problem_from_model /
solve_problem_from_file signatures are unchanged. Model.solve is
untouched (Phase C).

Surfaces solver name, status, io_api, and solution/report summary.

Move SolverFeature and _xpress_supports_gpu into linopy.solvers; declare
features/display_name as ClassVars on each Solver subclass with a
Solver.supports() classmethod. solver_capabilities becomes a back-compat
shim with a lazy SOLVER_REGISTRY mapping. Model.solve uses the class API
directly; SolverFeature is re-exported at the package top level.

Stash `sense` on the Solver instance in `to_solver_model` and make
`Solver.resolve()` take no args. Add `Model.to_solver_model(name)` and
`Model.resolve()` wrappers so the two-step direct-API flow lives on the
model. Update the direct-API test and re-run the piecewise notebook.

Model.to_solver_model -> prepare_solver and Model.resolve -> run_solver
(plus Solver.resolve/_resolve -> run/_run). Avoids the awkward "resolve
on first call" reading. Solver.to_solver_model is kept since it
accurately produces the native solver model.

Replace Xpress-specific _xpress_supports_gpu with a generic
_installed_version_in helper, and add Solver.runtime_features() as an
override hook for version/env-conditional capabilities. Xpress now
declares its GPU support via runtime_features() instead of inline
frozenset arithmetic on the class body.

…method

Move the full parameter docstring onto Solver.solve_problem_from_model and
drop the per-subclass duplicates on Mosek and cuPDLPx; subclasses now inherit
the abstract method's docstring.

Unify per-solver _translate_to_* methods under a common _build_solver_model
name, hoist their local imports to module top-level, drop dead params from
cuPDLPx (moving its UserWarning into the public to_solver_model), and add
TYPE_CHECKING stubs. Expand to_* deprecation messages with step-by-step
migration paths, wrap existing tests in pytest.warns, and cover the
unknown-solver-name branch in prepare_solver.

for more information, see https://pre-commit.ci

Replace pd.Series with dense NaN-padded np.ndarray keyed by integer
model labels. Adds values_to_lookup_array helper; simplifies
Model.apply_result; migrates every solver to build the lookup array
directly (direct-API solvers via cached _vlabels/_clabels, file-based
solvers via a shared _names_to_labels helper). Drops the now-unused
series_to_lookup_array and all name-based solution fallbacks.

Adds dual_bound field to SolverReport, populated by HiGHS, Gurobi
and Knitro. Declared via new SolverFeature.MIP_DUAL_BOUND_REPORT
so tests gate assertions on capability instead of solver names.

Mirror VariableLabelIndex on the constraint side: add
ConstraintBase.active_labels (cheap on both Constraint and CSRConstraint)
and a cached ConstraintLabelIndex on Constraints. Model.apply_result and
IIS extraction now read vlabels/clabels from these caches instead of
self.matrices, which previously rebuilt the full A matrix on every solve.

…rder

Restore the 43a82aa contract: Solution.primal and Solution.dual are
dense ndarrays indexed by linopy label with NaN at gaps. Each solver
builds the label-indexed form itself; apply_result shrinks to a direct
lookup_vals.

This fixes two classes of bugs the intermediate 'primal/dual in build
order' contract couldn't handle:

- File-based LP solvers iterate variables in objective-encounter order,
  which can interleave entries from multiple add_variables calls (e.g.
  non-aligned coords producing x0, x10, x1, x11, ...). Positional
  alignment with vlabels broke for every test exercising masked or
  non-aligned models on CBC / GLPK / Cplex / SCIP / Xpress.
- CPLEX drops entirely-unconstrained unused variables on LP read, so
  get_values() returns fewer values than the linopy model has labels;
  positional alignment errored at apply_result.

Implementation:

- _solution_from_names(values, names): file-based path. Parses linopy
  labels via the existing _names_to_labels helper and scatters values
  into a label-indexed array. Used by CBC, GLPK, Cplex, SCIP, Xpress,
  Knitro, COPT, MindOpt, and the from_file branches of Highs/Gurobi.
- _solution_from_labels(values, labels): direct-API path. Uses cached
  vlabels/clabels populated on the Solver instance at to_solver_model
  time. Used by Highs, Gurobi, Mosek, cuPDLPx.
- Highs and Gurobi from_file branches converge on _solution_from_names,
  replacing the inline keep + argsort pattern.

Solver is now a dataclass; subclasses inherit init. Construction routes
through Solver.from_name(name, model, io_api=..., options=...) which
builds at construction (direct API or LP/MPS file). solver.solve()
returns a Result; model.apply_result(result) writes the solution back.
Drops Model.prepare_solver/run_solver; to_* io helpers no longer warn.

…build_direct